1. Überblick
In diesem Artikel schauen wir uns an, wie eine Spring Boot Anwendung in einen Docker-Container verpackt und nach OpenShift deployt wird. Das Deployment werden wir lokal auf einer OpenShift (Minishift) Instanz durchführen, hierfür verwenden wir für das Bauen des Containers und das anschließende Deployen das Maven Plugin fabric8-maven-plugin.
Das Plugin unterstützt dich, deine Java Anwendung auf Kubernetes oder OpenShift zu bringen, hierfür übernimmt es folgende Aufgaben:
- Bauen des Docker-Containers mit deiner Anwendung
- Erstellen von Kubernetes / OpenShift Service und Deployment Konfigurationsdateien
Wir lassen uns von dem Plugin den Container mit unserer Anwendung bauen und diesen in das OpenShift Repository laden. Um den Deploy-Vorgang transparent zu halten, erzeugen wir die notwendigen Konfigurationsdateien manuell.
2. Minishift starten und Projekt anlegen
$ minishift start
Server Information ...
OpenShift server started.
The server is accessible via web console at:
https://192.168.64.5:8443/console
Nach erfolgreichem Start vom Minishift wird die Webadresse in der Konsole ausgegeben. Über den OpenShift Client loggen wir uns auf der Kommandozeile ein:
$ oc login https://192.168.64.5:8443
Username: developer
Password: developer
Login successful.
Wir erstellen ein neues Projekt:
$ oc new-project myproject --display-name="My Project"
3. Einbinden des Maven Plugins
In unsere pom.xml fügen wir das Plugin fabric8-maven-plugin hinzu:
pom.xml
<plugin>
<groupId>io.fabric8</groupId>
<artifactId>fabric8-maven-plugin</artifactId>
</plugin>
Das Plugin unterstützt einen Zero-Configuration Ansatz, bei dem der Entwickler nichts einzustellen braucht. Es werden Default Generatoren zum Bauen eines Docker Images verwendet. Weiterhin werden Default Ports beim Starten der Anwendung veröffentlicht. Der Ansatz ist ideal für kleine und simple Anwendung. Es ist aber auch möglich über XML-Konfiguration das Bauen des Docker Images selbst zu bestimmen, ähnlich zum Maven Plugin docker-maven-plugin, welches wir im Artikel
eigerichtet haben.
Für diesen Artikel reicht uns der Zero-Configuration Ansatz vollkommen aus, um unsere Beispielanwendung nach OpenShift zu deployen.
4. Bauen und Pushen des Docker Images
Das Bauen und Pushen des Docker Images in das OpenShift Repository übernimmt für uns vollständig das Plugin fabric8-maven-plugin, wir müssen lediglich folgendes Maven Goal ausführen:
$ mvn clean package fabric8:build
Mit diesem Befehl passiert schon die ganze Magie, das Docker Image wird gebaut und in das lokale OpenShift Repository gepusht. Da wir im ersten Schritt Minishift bereits gestartet haben und unser neu angelegtes Projekt ausgewählt haben, wird das gebaute Docker Image im Repository des neuen Projektes abgelegt.
Für das Bauen des Docker-Images wird ein eigener Source2Image Container verwendet, im /target Verzeichnis unserer Anwendung können wir uns das Dockerfile anschauen:
Dockerfile
FROM fabric8/s2i-java:2.3
ENV JAVA_APP_DIR=/deployments
LABEL org.label-schema.description="Demo project for Spring Boot" org.label-schema.version=0.0.1-SNAPSHOT org.label-schema.schema-version=1.0 org.label-schema.build-date=2020-02-24T17:48:35.576160 org.label-schema.name=sample-openshift-app org.label-schema.vcs-ref=c2d85d4d92bb521c77e912cb7641a6d2d9dda811 org.label-schema.url=https://projects.spring.io/spring-boot/#/spring-boot-starter-parent/sample-openshift-app org.label-schema.vcs-url=https://github.com/softwarehandwerk/sample-openshift-app.git
EXPOSE 8080 8778 9779
COPY maven /deployments/
Sobald das Pushen in das lokale OpenShift erfolgt ist, können wir uns den ImageStream auch in der OpenShift Weboberfläche anschauen.
Hierfür gehen wir, in unserem Fall auf folgende URL https://192.168.64.5:8443/console, anschließend sehen wir unter Builds > Images unseren frisch gebauten ImageStream.
5. Erstellen von Deployment / Service / Route Konfigurationen
Da wir das gebaute Docker-Image im ImageStream vom OpenShift vorliegen haben, müssen wir OpenShift nur noch mitteilen, wie er den Container starten und orchestrieren soll. Auch diesen Schritt kann das Maven Plugin fabric8-maven-plugin für uns übernehmen. Um den Vorgang transparent zu halten, erzeugen wir die Konfigurationsdateien aber manuell.
Deployment Config: app-deployment.yaml
kind: "DeploymentConfig"
apiVersion: "v1"
metadata:
name: "sample-openshift-app"
spec:
template:
metadata:
labels:
name: "sample-openshift-app"
spec:
containers:
- name: "sample-openshift-app"
ports:
- containerPort: 8080
protocol: "TCP"
replicas: 1
triggers:
- type: "ConfigChange"
- type: "ImageChange"
imageChangeParams:
automatic: true
containerNames:
- "sample-openshift-app"
from:
kind: "ImageStreamTag"
name: "sample-openshift-app:latest"
strategy:
type: "Rolling"
paused: false
revisionHistoryLimit: 2
Service Config: app-service.yaml
apiVersion: "v1"
kind: "Service"
metadata:
name: "sample-openshift-app-service"
spec:
ports:
- name: "web"
port: 8080
targetPort: 8080
selector:
name: "sample-openshift-app"
Route Config: app-route.yaml
apiVersion: "v1"
kind: "Route"
metadata:
name: "sample-openshift-app-route"
spec:
path: "/"
to:
kind: Service
name: "sample-openshift-app-service"
Für die Konfigurationsdateien erstellen wir in unserer Anwendung einen Ordner openshift/ und legen dort die oben beschriebenen YAML-Konfigurationen ab. Anschließend laden wir nacheinander die Konfigurationen über die Kommandozeile in OpenShift:
oc apply -f app-deployment.yaml
oc apply -f app-service.yaml
oc apply -f app-route.yaml
Die Orchestrierung deiner Anwendung übernimmt nun wie definiert OpenShift, in der Webkonsole kannst du deinen gestarteten Pod sehen und über die bereitgestellte Route im Browser aufrufen: http://sample-openshift-app-route-myproject.192.168.64.5.nip.io/
6. Fazit
Mit Hilfe des Maven Plugins von fabric8 ist das Deployen einer Java Anwendung auf OpenShift ziemlich einfach. Die Erstellung eines Docker-Containers und das eigentliche Deployen kann in den Maven Lifecycle integriert werden. Dadurch gelangt jede Code-Änderung automatisiert auf die Zielplatform OpenShift oder Kubernetes.
Source Code auf GitHub