Dein Erster Microservice Stack

Julian | Aug 28, 2025 min read
Dein Erster Microservice Stack

Hallo zusammen,

als Entwickler wissen wir, dass eine Anwendung zu schreiben nur die halbe Miete ist. Die andere Hälfte besteht darin, sie zuverlässig zu verpacken, auszurollen und zu betreiben. Hier kommt der Microservice-Stack mit Spring Boot, Docker und Kubernetes ins Spiel.

In diesem Guide bauen wir einen einfachen Spring Boot Microservice und machen ihn in zwei Schritten produktionsreif: Zuerst verpacken wir ihn in ein Docker-Image für die lokale Ausführung. Dann heben wir ihn auf die nächste Stufe und deployen ihn auf Kubernetes.

Der Artikel ist so aufgebaut, dass ihr den ersten Teil auch ohne Kubernetes-Cluster nachvollziehen könnt.

Anmerkung: Der Code wurde zu Testzwecken mit Warp erzeugt. Daher kann es zu leichten Diskrepanzen zwischen den Ausschnitten in diesem Post und dem tatsächlichen Code im Repository kommen.

Teil 1: Dein Spring Boot Microservice mit Docker

1. Die Anwendung schreiben

Wir starten mit einer simplen REST-API, die eine Begrüßung zurückgibt.

Benötigte Dependencies:

  • Spring Web
  • Spring Boot DevTools
  • Lombok

Erstelle ein neues Spring Boot Projekt mit diesen Dependencies und füge folgende Klassen hinzu:

src/main/java/com/example/demo/controller/GreetingController.java

package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {

    @GetMapping("/hello")
    public String sayHello(@RequestParam(value = "name", defaultValue = "World") String name) {
        return String.format("Hello, %s!", name);
    }
}

Dieser Controller erstellt einen Endpunkt /hello, der einen optionalen Namen-Parameter akzeptiert. Wenn kein Name übergeben wird, wird standardmäßig “World” verwendet.

2. Die Dockerfile erstellen

Damit wir unsere Anwendung mit Docker ausführen können, benötigen wir eine Dockerfile. Lege diese Datei im Wurzelverzeichnis deines Projekts ab.

Dockerfile

# Wir nutzen das offizielle OpenJDK 17-JDK-Image als Basis
FROM openjdk:17-jdk-slim

# Metadaten fuer unser Image
LABEL authors="Julian Paul"
LABEL description="Mein erster Spring Boot Microservice"

# Wir definieren ein Argument fuer den JAR-Dateinamen
ARG JAR_FILE=target/*.jar

# Kopiere die kompilierte JAR-Datei in den Container
COPY ${JAR_FILE} app.jar

# Definiere das Arbeitsverzeichnis
WORKDIR /

# Starte die Anwendung, wenn der Container laeuft
ENTRYPOINT ["java", "-jar", "app.jar"]

Diese Dockerfile ist schlank und effizient. Sie kopiert die fertig kompilierte JAR-Datei in das Image, was den Build-Prozess beschleunigt, da die Kompilierung außerhalb von Docker erfolgt.

3. Die Anwendung bauen und als Docker-Image verpacken

Öffne ein Terminal in deinem Projektverzeichnis.

  1. Spring Boot Anwendung bauen:

    ./mvnw package

    Dieser Befehl kompiliert den Code, führt die Tests aus und erstellt die .jar-Datei im target/-Verzeichnis.

  2. Docker-Image bauen:

    docker build -t my-microservice .

    Mit docker build bauen wir das Image aus der Dockerfile. -t my-microservice taggt das Image mit dem Namen my-microservice und . gibt an, dass die Dockerfile im aktuellen Verzeichnis liegt.

  3. Docker-Container ausführen:

    docker run -p 8080:8080 my-microservice
    • docker run startet einen Container.
    • -p 8080:8080 bildet den Port 8080 des Containers auf den Port 8080 deines lokalen Rechners ab.
    • my-microservice ist der Name des Images, das wir gerade gebaut haben.

Wenn alles geklappt hat, ist eure Anwendung jetzt unter http://localhost:8080/hello erreichbar.

Teil 2: Deployment auf Kubernetes

Wenn dein Microservice produktiv gehen soll, brauchst du eine skalierbare Plattform. Kubernetes ist dafür der Goldstandard.

Wichtig: Für diesen Teil brauchst du ein laufendes Kubernetes-Cluster (z.B. mit Minikube, Docker Desktop oder einem Cloud-Anbieter wie AWS EKS, Google GKE).

1. Das Docker-Image in eine Registry pushen

Damit Kubernetes dein Image finden kann, muss es in einer Registry gespeichert sein. Wir verwenden hierzu Docker Hub.

  1. Bei Docker Hub einloggen:

    docker login

  2. Image taggen:

    docker tag my-microservice:latest dein-dockerhub-username/my-microservice:v1

    Ersetze dein-dockerhub-username mit deinem tatsächlichen Docker Hub Username.

  3. Image pushen:

    docker push dein-dockerhub-username/my-microservice:v1

2. Das Deployment-Manifest schreiben

Ein Deployment-Manifest beschreibt, wie Kubernetes deine Anwendung ausrollen soll. Erstelle eine Datei namens deployment.yaml.

deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-microservice-deployment
  labels:
    app: my-microservice
spec:
  replicas: 1 # Starte mit einer Instanz (Pod)
  selector:
    matchLabels:
      app: my-microservice
  template:
    metadata:
      labels:
        app: my-microservice
    spec:
      containers:
      - name: my-microservice
        image: dein-dockerhub-username/my-microservice:v1 # Hier dein Image-Pfad
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: my-microservice-service
spec:
  selector:
    app: my-microservice
  type: LoadBalancer # Oder NodePort, je nach Umgebung
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 8080
  • Deployment: Stellt sicher, dass immer die angegebene Anzahl an Pod-Instanzen läuft.
  • Service: Erlaubt den Zugriff auf deine Pods, indem es Anfragen an sie weiterleitet. Der Typ LoadBalancer erstellt eine externe IP-Adresse (in Cloud-Umgebungen). Für lokale Setups wie Minikube ist NodePort oft einfacher.

3. Deployment auf Kubernetes ausführen

Öffne ein Terminal mit Zugang zu deinem Cluster und wende das Manifest an:

kubectl apply -f deployment.yaml

Das kubectl Tool liest deine deployment.yaml und weist Kubernetes an, deine Anwendung auszurollen.

4. Die Anwendung auf Kubernetes aufrufen

Finde die externe IP-Adresse deines Service:

kubectl get services my-microservice-service

Unter der Spalte EXTERNAL-IP findest du die Adresse, unter der deine Anwendung erreichbar ist.

Fazit

Glückwunsch! Du hast soeben deine erste Spring Boot Anwendung in ein Docker-Image verpackt und auf Kubernetes deployed. Dies ist der grundlegende Stack für moderne Microservices. Von hier aus kannst du dein Wissen vertiefen und fortgeschrittene Konzepte wie ConfigMaps, Secrets, Ingress und Helm Charts erkunden.

Benötigte Dependencies

Für das Spring Boot Projekt im pom.xml (Maven) oder build.gradle (Gradle) benötigst du die folgenden Dependencies:

Maven (pom.xml)

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

Gradle (build.gradle)

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    developmentOnly 'org.springframework.boot:spring-boot-devtools'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
}

Code on Codeberg