VBO Wiki

12. DevOps & Monitoring (Docker)

3 min read

RU | EN | DE

1. Dockerisierung der Spring Boot Anwendung

📄 Dockerfile (Multi-Stage Build):

1. Anwendung erstellen
FROM maven:3.9.6-eclipse-temurin-17 AS build
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn clean package -DskipTests
2. Fertiges Jar starten
FROM eclipse-temurin:17-jdk
WORKDIR /app
COPY --from=build /app/target/demo-0.0.1-SNAPSHOT.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

📌 Befehle:

docker build -t demo-app .
docker run -p 8080:8080 demo-app

2. Actuator (Metriken und Monitoring)

📄 Abhängigkeit:

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

📄 Konfiguration:

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,env,beans
  endpoint:
    health:
      show-details: always

📌 Verfügbare Endpunkte:

  • /actuator/health → Zustand
  • /actuator/info → Info über die Anwendung
  • /actuator/metrics → Metriken (JVM, CPU, Heap)
  • /actuator/beans → Liste der Beans

3. Micrometer (Metriken für Prometheus/Grafana)

Spring Boot 3 verwendet Micrometer als universelle Metrik-Schicht.

📄 Abhängigkeit für Prometheus:

<dependency>
  <groupId>io.micrometer</groupId>
  <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

📌 Jetzt verfügbar: http://localhost:8080/actuator/prometheus

📄 Metriken:

  • jvm.memory.used
  • system.cpu.usage
  • http.server.requests

📄 Eigene Metriken:

@Component
@RequiredArgsConstructor
public class CustomMetrics {
    private final MeterRegistry registry;
    @PostConstruct
    public void init() {
        Gauge.builder("app.users.count", () -> 42)
             .description("Anzahl der Benutzer")
             .register(registry);
    }
}

4. Centralized Logging (ELK / Loki)

ELK (Elasticsearch + Logstash + Kibana) Variante

📄 In application.yml:

logging:
  level:
    root: INFO
    com.example: DEBUG
  file:
    name: /var/log/app.log

📌 Logstash sammelt die Logs → in Elasticsearch → Ansicht über Kibana.

Loki + Grafana Variante

📌 Leichter Stack (Promtail → Loki → Grafana). Spring schreibt in stdout, Promtail sammelt und sendet an Loki.

5. CI/CD (GitHub Actions)

📄 .github/workflows/ci.yml:

name: Java CI with Maven
on:
  push:
    branches: [ "main" ]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'
      - name: Build with Maven
        run: mvn -B clean verify
      - name: Build Docker image
        run: docker build -t demo-app .

📌 Weiterhin kann der Deployment in DockerHub oder Kubernetes konfiguriert werden.

6. Kubernetes (K8s Deployment)

📄 deployment.yml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: demo-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: demo-app
  template:
    metadata:
      labels:
        app: demo-app
    spec:
      containers:
      - name: demo-app
        image: demo-app:latest
        ports:
        - containerPort: 8080

📄 service.yml:

apiVersion: v1
kind: Service
metadata:
  name: demo-app-service
spec:
  type: LoadBalancer
  selector:
    app: demo-app
  ports:
  - port: 80
    targetPort: 8080

7. Updates ohne Ausfallzeit (Zero-Downtime Deploy)

  • Kubernetes Rolling Updates verwenden.
  • Für Spring Boot:
  • graceful shutdown → spring.lifecycle.timeout-per-shutdown-phase=30s.
  • readiness/liveness-Prüfungen über /actuator/health.

8. Best Practices

  • ✅ Actuator + Prometheus/Grafana verwenden → Monitoring und Alarme.
  • ✅ Logs zentralisieren (ELK/Loki).
  • ✅ Anwendung immer in Docker ausführen.
  • ✅ In der Produktion Kubernetes oder ECS/EKS/GKE verwenden.
  • ✅ CI/CD-Pipeline Schritte: test → build → dockerize → deploy.
  • ✅ Health-Checks und graceful shutdown konfigurieren.

Backlinks