Kubernetes im Unternehmen: Schritt-für-Schritt-Anleitung zur Container-Orchestrierung mit Docker, Microservices und REST-APIs

Einführung in Kubernetes für Enterprise Software Architecture

Kubernetes hat sich als Standard für die Container-Orchestrierung in modernen Unternehmen etabliert. In diesem Tutorial zeigen wir Ihnen, wie Sie eine vollständige Microservices-Architektur mit Docker, Kubernetes und REST-APIs aufsetzen. Die Schritte orientieren sich an typischen Aufgaben aus dem Kurs CS 548 Enterprise Software Architecture and Design und sind so aufbereitet, dass Sie sie direkt in Ihrer Entwicklungsumgebung nachvollziehen können.

Warum Kubernetes? Aktuelle Trends und Beispiele

Stellen Sie sich vor, Sie entwickeln eine Plattform wie das KI-gestützte Diagnosetool, das aktuell in der Gesundheitsbranche diskutiert wird. Solche Systeme müssen tausende Anfragen pro Sekunde verarbeiten und gleichzeitig zuverlässig laufen. Kubernetes ermöglicht genau das: automatische Skalierung, Self-Healing und einfache Verwaltung von Containern. Auch in der Finanzbranche setzen Unternehmen wie die Deutsche Bank auf Kubernetes, um Trading-Plattformen auszurollen. Oder denken Sie an Gaming-Plattformen wie die, die während der Fußball-WM 2026 Live-Ergebnisse streamen – auch sie nutzen Kubernetes, um Lastspitzen abzufedern.

1. Docker-Image für die Datenbank erstellen und bereitstellen

Der erste Schritt in Ihrer Kubernetes-Reise ist die Erstellung eines Docker-Images für Ihre Datenbank. Wir verwenden PostgreSQL als Beispiel, da es in vielen Enterprise-Anwendungen zum Einsatz kommt.

Dockerfile für PostgreSQL

FROM postgres:16
ENV POSTGRES_DB=healthcare
ENV POSTGRES_USER=admin
ENV POSTGRES_PASSWORD=secret
COPY init.sql /docker-entrypoint-initdb.d/

Das init.sql Skript kann Tabellen für Patienten, Ärzte und Behandlungen anlegen. Bauen Sie das Image mit docker build -t healthcare-db:1.0 . und pushen Sie es in Ihre Registry (z.B. Docker Hub oder eine private Registry).

Deployment und Service in Kubernetes

Erstellen Sie eine YAML-Datei für das Deployment und den Service:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgres-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
      - name: postgres
        image: healthcare-db:1.0
        ports:
        - containerPort: 5432
---
apiVersion: v1
kind: Service
metadata:
  name: postgres-service
spec:
  selector:
    app: postgres
  ports:
  - port: 5432
    targetPort: 5432

Wenden Sie die Konfiguration mit kubectl apply -f postgres.yaml an. Beschreiben Sie den Service mit kubectl describe service postgres-service. Zeigen Sie die Logs des Datenbank-Containers mit kubectl logs -l app=postgres an. Um die Tabellen zu sehen, verbinden Sie sich via IntelliJ Database Tool mit dem Service (Host: localhost, Port: 5432, User: admin, Passwort: secret).

2. Microservice bereitstellen und testen

Ein Microservice in Kubernetes besteht aus einem Deployment und einem Service. Wir nehmen einen einfachen Spring Boot Microservice, der Patientendaten verwaltet.

Deployment und Service für den Microservice

apiVersion: apps/v1
kind: Deployment
metadata:
  name: patient-service
spec:
  replicas: 2
  selector:
    matchLabels:
      app: patient-service
  template:
    metadata:
      labels:
        app: patient-service
    spec:
      containers:
      - name: patient-service
        image: patient-service:1.0
        ports:
        - containerPort: 8080
        livenessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
  name: patient-service
spec:
  selector:
    app: patient-service
  ports:
  - port: 80
    targetPort: 8080
  type: LoadBalancer

Beachten Sie den Health Check (Liveness Probe). Kubernetes prüft regelmäßig, ob der Microservice lebt. Starten Sie das Deployment und zeigen Sie die Logs mit kubectl logs -l app=patient-service. Testen Sie Query-Operationen im Browser: http://localhost/patients sollte eine Liste zurückgeben.

3. Web-App bereitstellen

Die Web-App (z.B. ein Angular-Frontend) kommuniziert mit dem Microservice. Erstellen Sie ein Deployment und einen Service analog zu oben. Stellen Sie sicher, dass die Web-App die Backend-URL (z.B. http://patient-service) verwendet.

Testen Sie im Browser: Die Web-App sollte Patienten anzeigen. Prüfen Sie in den Logs der Web-App (kubectl logs -l app=webapp), ob Aufrufe an den Microservice erfolgen.

4. REST-Webservice bereitstellen

Ein separater REST-Webservice kann z.B. für die Integration mit Drittsystemen dienen. Deployment und Service sind ähnlich wie beim Microservice. Testen Sie Query-Operationen wie http://rest-service/api/treatments im Browser und zeigen Sie die Logs.

5. Daten über REST-Client hinzufügen und in der Web-App anzeigen

Verwenden Sie einen REST-Client (z.B. Postman oder curl), um Patienten, Ärzte und Behandlungen anzulegen:

curl -X POST http://rest-service/api/patients -H "Content-Type: application/json" -d '{"name":"Max Mustermann","birthDate":"1990-01-01"}'

Rufen Sie anschließend die Web-App auf – die neuen Daten sollten sichtbar sein. Prüfen Sie in der Datenbank (via IntelliJ), ob die Einträge korrekt gespeichert wurden.

Zusammenfassung und Best Practices

Sie haben nun eine vollständige Kubernetes-Umgebung mit Datenbank, Microservice, Web-App und REST-API aufgebaut. Wichtige Punkte:

• Health Checks sind essenziell für Self-Healing.
• Logging mit kubectl logs hilft bei der Fehlersuche.
• Services ermöglichen die Kommunikation zwischen Komponenten.
• Skalierung durch Anpassen der Replicas in Deployments.

Kubernetes ist ein mächtiges Werkzeug, das in der Cloud-Native-Entwicklung und bei KI-Anwendungen immer wichtiger wird. Mit dieser Anleitung sind Sie bereit für die nächste Herausforderung – ob in der Fintech-Branche oder im E-Commerce.